import 'dart:async';
import 'dart:convert';
import 'dart:io';

import 'package:dio/dio.dart' as dio;
import 'package:flutter/foundation.dart';
import 'package:flutter_09_game/application.dart';
import 'package:flutter_09_game/config/app_config.dart';
import 'package:flutter_09_game/config/app_routes.dart';
import 'package:flutter_09_game/generated/locales.g.dart';
import 'package:flutter_09_game/http/http_export.dart';
import 'package:flutter_09_game/manager/ws_manager.dart';
import 'package:flutter_09_game/pages/splash/model_api_config.dart';
import 'package:flutter_09_game/user/app_user_manager.dart';
import 'package:flutter_09_game/utils/loading/loading_utils.dart';
import 'package:flutter_09_game/utils/log/utils_log.dart';
import 'package:flutter_09_game/utils/shared/shared_export.dart';
import 'package:flutter_09_game/utils/utils_api_checker.dart';
import 'package:flutter_09_game/utils/connectivity_utils.dart';
import 'package:get/get.dart';
import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:path_provider/path_provider.dart';

class SplashLogic extends GetxController {
  // 网络监听状态
  bool _isListeningNetwork = false;

  @override
  void onInit() {
    super.onInit();

    // Future.delayed(const Duration(milliseconds: 300), () {
    LoadingUtils.showLoading();
    _checkNetworkStatus().then((value) {
      if (value) {
        _initializeApp();
      }
    });
    // });
    // Widget
  }

  /// 初始化应用
  void _initializeApp() async {
    try {
      // 获取API配置
      ModelApiConfig apiConfig = kDebugMode
          ? AppConfig.defaultApiConfig
          : SharedStorage().getApiConfig();

      if ((apiConfig.pool ?? []).isNotEmpty) {
        await _retryApiRequests((apiConfig.pool ?? []));
      } else {
        // 没有可用API，使用默认配置
        clog('没有可用的API，使用默认配置', tag: 'API');
        _handleAllApisFailed();
      }
    } catch (e) {
      clog('初始化应用失败: $e', tag: 'API');
      _handleAllApisFailed();
    }
  }

  // Future<String> _generateSavePath(String url) async {
  //   try {
  //     // 获取临时目录
  //     final tempDir = await getTemporaryDirectory();
  //
  //     // 创建下载子目录
  //     final downloadDir = Directory('${tempDir.path}/downloads');
  //     if (!await downloadDir.exists()) {
  //       await downloadDir.create(recursive: true);
  //       clog('创建下载目录: ${downloadDir.path}', tag: 'API');
  //     }
  //
  //     // 从URL生成文件名
  //     final uri = Uri.parse(url);
  //     String fileName;
  //
  //     // 安全获取文件名
  //     if (uri.pathSegments.isNotEmpty) {
  //       fileName = uri.pathSegments.last;
  //     } else {
  //       fileName = '';
  //     }
  //
  //     // 如果文件名为空或无效，生成时间戳文件名
  //     if (fileName.isEmpty || !fileName.contains('.')) {
  //       fileName = 'download_${DateTime.now().millisecondsSinceEpoch}.json';
  //     }
  //
  //     // 清理文件名中的特殊字符
  //     fileName = fileName.replaceAll(RegExp(r'[<>:"/\\|?*]'), '_');
  //
  //     // 拼接完整路径
  //     final savePath = '${downloadDir.path}/$fileName';
  //
  //     clog('生成保存路径: $savePath', tag: 'API');
  //     return savePath;
  //   } catch (e) {
  //     clog('生成保存路径失败: $e', tag: 'API');
  //     // 降级方案：使用默认路径
  //     final fallbackPath =
  //         '/tmp/download_${DateTime.now().millisecondsSinceEpoch}.json';
  //     clog('使用降级路径: $fallbackPath', tag: 'API');
  //     return fallbackPath;
  //   }
  // }

  /// 检查单个API是否可用
  /// [url] API地址
  /// 返回true表示成功，false表示失败
  Future<ModelApiConfig?> checkPoolUrl(String url) async {
    try {
      // 1. 下载文件
      // String savePath = await _generateSavePath(url);

      // HttpResponse response = await HttpManager().get(
      //   url,
      // );
      dio.Response response = await HttpManager().getDio().get(url);
      // HttpResponse response =   await HttpManager().get( url, );
      // Dio

      clog('dalksdjl  ${response.data}');

      // HttpResponse downloadResponse =
      //     await HttpManager().download(url: url, savePath: savePath);

      if (response.data == null) {
        return null;
      }

      // 2. 读取文件内容
      // File configFile = File(savePath);
      // if (!await configFile.exists()) {
      //   return null;
      // }

      // String jsonContent = await configFile.readAsString();

      // 3. 解析 JSON 为 ModelApiConfig
      // Map<String, dynamic> jsonMap = jsonDecode(jsonContent);
      // clog('jsonMap   $jsonMap');
      ModelApiConfig config = ModelApiConfig.fromJson(response.data);

      return config;
    } catch (e) {
      clog('下载和解析配置失败: $e', tag: 'API');
      return null;
    }
  }

  /// 获取 pool 接口的配置数据
  /// [url] pool 接口地址
  /// 返回解析后的配置对象，失败时返回 null
  // Future<ModelApiConfig?> getPoolConfig(String url) async {
  //   try {
  //     clog('正在获取 pool 配置: $url', tag: 'API');
  //
  //     HttpResponse response = await HttpManager().get(
  //       url,
  //       fromJson: ModelApiConfig.fromJson,
  //       uiType: HttpUIType.none, // 静默请求，不显示加载状态
  //     );
  //
  //     if (response.isSuccess && response.data != null) {
  //       clog('pool 配置获取成功: $url', tag: 'API');
  //       return response.data;
  //     } else {
  //       clog('pool 配置获取失败: $url, 错误: ${response.msg ?? '未知错误'}', tag: 'API');
  //       return null;
  //     }
  //   } catch (e) {
  //     clog('pool 配置获取异常: $url, 异常: $e', tag: 'API');
  //     return null;
  //   }
  // }

  /// 循环重试API请求
  /// [availableApis] 可用的API列表
  Future<void> _retryApiRequests(List<String> availableApis) async {
    // const Duration retryInterval = Duration(seconds: 2);
    int currentIndex = 0;

    clog('开始循环重试API请求，共${availableApis.length}个API', tag: 'API');

    for (String api in availableApis) {
      currentIndex++;
      clog('尝试第${currentIndex}/${availableApis.length}个API: $api', tag: 'API');

      try {
        ModelApiConfig? apiConfig = await checkPoolUrl(api);
        if (apiConfig != null) {
          // API测试成功，应用配置
          await _handleApiSuccess(apiConfig);
          return; // 成功，停止循环
        } else {
          // API测试失败，等待后继续下一个
          if (currentIndex < availableApis.length) {
            clog('API失败，尝试下一个', tag: 'API');
            // await Future.delayed(retryInterval);
          }
        }
      } catch (e) {
        clog('API请求异常: $api, 异常: $e', tag: 'API');
        // if (currentIndex < availableApis.length) {
        // await Future.delayed(retryInterval);
        // }
      }
    }

    // 所有API都失败了
    clog('所有API都测试失败，使用降级处理', tag: 'API');
    _handleAllApisFailed();
  }

  /// 处理API成功的情况
  /// [poolConfig] 成功获取的pool配置
  Future<void> _handleApiSuccess(ModelApiConfig poolConfig) async {
    clog('Pool配置获取成功，启动快速启动流程', tag: 'API');
    // 使用新的快速启动流程
    await _quickStart(poolConfig);
  }

  /// 处理所有API失败的情况
  void _handleAllApisFailed() async {
    clog('所有API都失败，使用默认配置', tag: 'API');

    // 使用默认配置
    ModelApiConfig apiConfig = AppConfig.defaultApiConfig;
    await _completeConfigInBackground(apiConfig, setApi: true);
    navigateToNextPage();
    // checkApiConfig(apiConfig, isSave: false);
  }

  /// 检查网络状态
  Future<bool> _checkNetworkStatus() async {
    try {
      final bool isConnected = await ConnectivityUtils.isConnected();

      if (isConnected) {
        clog('网络连接正常', tag: 'Network');
        return true;
      } else {
        _startNetworkListening();
        return false;
      }
    } catch (e) {
      clog('网络状态检查失败: $e', tag: 'Network');
      return false;
    }
  }

  /// 开始网络监听
  void _startNetworkListening() {
    if (_isListeningNetwork) {
      clog('网络监听已在进行中，跳过重复启动', tag: 'Network');
      return;
    }

    _isListeningNetwork = true;
    clog('开始监听网络状态变化', tag: 'Network');

    ConnectivityUtils.startListening((results) {
      _onNetworkStatusChanged(results);
    });
  }

  /// 网络状态变化回调
  void _onNetworkStatusChanged(List<ConnectivityResult> results) async {
    clog('网络状态发生变化: ${results.map((e) => e.name).join(', ')}', tag: 'Network');

    // 检查是否有可用网络连接
    final bool hasConnection =
        results.isNotEmpty && !results.contains(ConnectivityResult.none);

    if (hasConnection && _isListeningNetwork) {
      clog('网络已恢复，停止监听并初始化应用', tag: 'Network');
      // 停止监听
      // ConnectivityUtils.stopListening();
      _stopNetworkListening();
      _initializeApp();
    }
  }

  /// 停止网络监听
  void _stopNetworkListening() {
    if (_isListeningNetwork) {
      ConnectivityUtils.stopListening();
      _isListeningNetwork = false;
      clog('网络监听已停止', tag: 'Network');
    }
  }

  void navigateToNextPage() async {
    LoadingUtils.dismiss();

    if (AppUserManager().isLogin()) {
      AppUserManager().refreshUserInfo();
      AppUserManager().loadWalletData();
      // WsManager().checkAndConnect();
    }
    Get.offAllNamed(AppRoutes.main);
  }

  /// 竞速检测API域名，返回最快可用的域名
  /// [apis] API域名列表
  /// 返回第一个可用的域名，如果全部失败则返回null
  Future<String?> _raceCheckApis(List<String> apis) async {
    if (apis.isEmpty) return null;

    final completer = Completer<String?>();
    int completedCount = 0;

    clog('开始竞速检测 ${apis} 个API域名', tag: 'API-Race');

    for (String api in apis) {
      UtilsApiChecker.checkSingleApiWithSpeed(api,
              timeout: const Duration(seconds: 5))
          .then((result) {
        if (!completer.isCompleted && result != null) {
          // 第一个成功的立即返回
          completer.complete(result);
          clog('竞速检测成功: $result (最快响应)', tag: 'API-Race');
        }

        completedCount++;
        if (completedCount == apis.length && !completer.isCompleted) {
          // 所有都失败了
          clog('竞速检测失败: 所有API都不可用', tag: 'API-Race');
          completer.complete(null);
        }
      });
    }

    return completer.future;
  }

  /// 快速启动：使用竞速模式检测API并立即进入APP
  /// [poolConfig] 从pool获取的配置
  Future<void> _quickStart(ModelApiConfig poolConfig) async {
    clog('开始快速启动流程', tag: 'QuickStart');

    // 竞速检测API域名
    String? fastestApi = await _raceCheckApis((poolConfig.api ?? []));
    String? fastestFile = await _raceCheckApis(poolConfig.file ?? []);
    // String? fastestFrontend ;
    // await Future.wait([
    //   _raceCheckApis(poolConfig.api ?? []).then((value) {
    //     fastestApi = value;
    //   }),
    //   _raceCheckApis(poolConfig.file ?? []).then((value) {
    //     fastestFile = value;
    //   }),
    // ]);

    //     AppConfig.baseImage = files.firstOrNull ?? '';
    //     AppConfig.shareUrl = frontends.firstOrNull ?? '';

    if (fastestApi != null) {
      // 立即设置基础配置
      AppConfig.baseUrl = fastestApi ?? '';
      HttpManager().setBaseUrl(AppConfig.baseUrl);

      // 使用pool配置的第一个作为临时配置
      AppConfig.baseImage = fastestFile ?? '';
      // AppConfig.shareUrl = (poolConfig.frontend ?? []).firstOrNull ?? '';
      _raceCheckApis(poolConfig.frontend ?? []).then((value) {
        AppConfig.shareUrl = value ?? '';
      });

      clog(
          '快速启动成功 - API: $fastestApi, Image: ${AppConfig.baseImage}, Share: ${AppConfig.shareUrl}',
          tag: 'QuickStart');

      // 立即进入APP
      navigateToNextPage();

      // 后台继续完善配置
      _completeConfigInBackground(poolConfig);
    } else {
      // 竞速失败，使用默认配置
      clog('竞速检测失败，使用默认配置', tag: 'QuickStart');
      _handleAllApisFailed();
    }
  }

  /// 后台完善配置：检测所有域名并保存完整配置
  /// [poolConfig] 从pool获取的配置
  /// 此方法在用户已进入APP后在后台执行，不阻塞用户操作
  Future<void> _completeConfigInBackground(ModelApiConfig poolConfig,
      {bool setApi = false}) async {
    clog('开始后台完善配置', tag: 'Background');
    if (setApi) {
      await Future.delayed(const Duration(seconds: 3));
    }
    try {
      // 并发检测所有类型域名
      List<String> apis =
          await UtilsApiChecker.checkAvailableApis((poolConfig.api ?? []));
      List<String> files =
          await UtilsApiChecker.checkAvailableApis((poolConfig.file ?? []));
      List<String> frontends =
          await UtilsApiChecker.checkAvailableApis((poolConfig.frontend ?? []));
      List<String> pools =
          await UtilsApiChecker.checkAvailableApis((poolConfig.pool ?? []));

      // await Future.wait([
      // await   UtilsApiChecker.checkAvailableApis((poolConfig.api ?? []))
      //        .then((value) {
      //      apis = value;
      //    });
      //    UtilsApiChecker.checkAvailableApis((poolConfig.file ?? []))
      //        .then((value) => files = value);
      //    UtilsApiChecker.checkAvailableApis((poolConfig.frontend ?? []))
      //        .then((value) => frontends = value);
      //    UtilsApiChecker.checkAvailableApis((poolConfig.pool ?? []))
      //        .then((value) => pools = value);
      // ]);

      // 更新完整配置
      if (apis.isNotEmpty) {
        ModelApiConfig completeConfig = ModelApiConfig(
          api: apis,
          file: files,
          frontend: frontends,
          pool: pools,
          websocket: poolConfig.websocket,
          // download: poolConfig.download,
        );

        if (setApi) {
          AppConfig.baseUrl = apis.firstOrNull ?? '';
          HttpManager().setBaseUrl(AppConfig.baseUrl);
        }

        // 更新全局配置
        // Application.isNeedConfig = false;
        AppConfig.defaultApiConfig = completeConfig;

        // 如果发现更好的配置，更新当前使用的
        if (files.isNotEmpty && AppConfig.baseImage.isEmpty) {
          AppConfig.baseImage = files.first;
          clog('后台更新 baseImage: ${files.first}', tag: 'Background');
        }
        if (frontends.isNotEmpty && AppConfig.shareUrl.isEmpty) {
          AppConfig.shareUrl = frontends.first;
          clog('后台更新 shareUrl: ${frontends.first}', tag: 'Background');
        }

        // 保存到本地
        SharedStorage().setApiConfig(completeConfig);

        clog(
            '后台配置完善成功 - 可用域名统计: api=${apis.length}, file=${files.length}, '
            'frontend=${frontends.length}, pool=${pools.length}',
            tag: 'Background');
      } else {
        clog('后台配置完善失败: 没有可用的API域名', tag: 'Background');
      }
    } catch (e) {
      clog('后台配置完善异常: $e', tag: 'Background');
    }
  }

  // checkApiConfig(ModelApiConfig apiConfig, {bool isSave = false}) async {
  //   List<String> apis = [];
  //   List<String> files = [];
  //   List<String> frontends = [];
  //   List<String> pools = [];
  //   await Future.wait([
  //     // List<String> apis =
  //     UtilsApiChecker.checkAvailableApis((apiConfig.api ?? [])).then((value) {
  //       apis = value;
  //     }),
  //     UtilsApiChecker.checkAvailableApis((apiConfig.file ?? [])).then((value) {
  //       files = value;
  //     }),
  //     UtilsApiChecker.checkAvailableApis((apiConfig.frontend ?? []))
  //         .then((value) {
  //       frontends = value;
  //     }),
  //     UtilsApiChecker.checkAvailableApis((apiConfig.pool ?? [])).then((value) {
  //       pools = value;
  //     }),
  //   ]);
  //
  //   if (apis.isNotEmpty) {
  //     AppConfig.baseUrl = apis.first;
  //     HttpManager().setBaseUrl(AppConfig.baseUrl);
  //     AppConfig.baseImage = files.firstOrNull ?? '';
  //     AppConfig.shareUrl = frontends.firstOrNull ?? '';
  //
  //     clog(
  //         '开始配置   ${AppConfig.baseUrl}   ${AppConfig.baseImage}   ${AppConfig.shareUrl}');
  //
  //     clog('可使用的地址  ${apiConfig.toJson()}');
  //     ModelApiConfig newConfig = ModelApiConfig(
  //         api: apis,
  //         file: files,
  //         frontend: frontends,
  //         pool: pools,
  //         websocket: apiConfig.websocket);
  //     // Application.isNeedConfig = false;
  //     AppConfig.defaultApiConfig = newConfig;
  //     if (isSave) {
  //       SharedStorage().setApiConfig(newConfig);
  //     }
  //     navigateToNextPage();
  //   }
  //   LoadingUtils.dismiss();
  // }

  @override
  void onClose() {
    // 清理网络监听器
    _stopNetworkListening();
    super.onClose();
  }
}
